home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / managers / FocusManager.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  31.3 KB  |  970 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.InteractiveObject;
  6.    import flash.display.Sprite;
  7.    import flash.events.Event;
  8.    import flash.events.FocusEvent;
  9.    import flash.events.KeyboardEvent;
  10.    import flash.events.MouseEvent;
  11.    import flash.system.Capabilities;
  12.    import flash.text.TextField;
  13.    import flash.ui.Keyboard;
  14.    import mx.core.FlexSprite;
  15.    import mx.core.IButton;
  16.    import mx.core.IChildList;
  17.    import mx.core.IRawChildrenContainer;
  18.    import mx.core.IUIComponent;
  19.    import mx.core.mx_internal;
  20.    import mx.events.FlexEvent;
  21.    
  22.    use namespace mx_internal;
  23.    
  24.    public class FocusManager implements IFocusManager
  25.    {
  26.       mx_internal static const VERSION:String = "3.0.0.0";
  27.       
  28.       private var focusableObjects:Array;
  29.       
  30.       private var _showFocusIndicator:Boolean = false;
  31.       
  32.       private var defButton:IButton;
  33.       
  34.       private var _form:IFocusManagerContainer;
  35.       
  36.       private var focusableCandidates:Array;
  37.       
  38.       private var LARGE_TAB_INDEX:int = 99999;
  39.       
  40.       private var browserFocusComponent:InteractiveObject;
  41.       
  42.       private var activated:Boolean = false;
  43.       
  44.       private var _defaultButton:IButton;
  45.       
  46.       private var calculateCandidates:Boolean = true;
  47.       
  48.       private var _focusPane:Sprite;
  49.       
  50.       private var lastFocus:IFocusManagerComponent;
  51.       
  52.       private var _defaultButtonEnabled:Boolean = true;
  53.       
  54.       public var browserMode:Boolean;
  55.       
  56.       private var lastAction:String;
  57.       
  58.       public function FocusManager(param1:IFocusManagerContainer, param2:Boolean = false)
  59.       {
  60.          super();
  61.          browserMode = Capabilities.playerType == "ActiveX" && !param2;
  62.          param1.focusManager = this;
  63.          _form = param1;
  64.          focusableObjects = [];
  65.          focusPane = new FlexSprite();
  66.          focusPane.name = "focusPane";
  67.          addFocusables(DisplayObject(param1));
  68.          param1.addEventListener(Event.ADDED,addedHandler);
  69.          param1.addEventListener(Event.REMOVED,removedHandler);
  70.          param1.addEventListener(FlexEvent.SHOW,showHandler);
  71.          param1.addEventListener(FlexEvent.HIDE,hideHandler);
  72.          if(param1.systemManager is SystemManager)
  73.          {
  74.             if(param1 != SystemManager(param1.systemManager).application)
  75.             {
  76.                param1.addEventListener(FlexEvent.CREATION_COMPLETE,creationCompleteHandler);
  77.             }
  78.          }
  79.          param1.systemManager.addFocusManager(param1);
  80.       }
  81.       
  82.       public function deactivate() : void
  83.       {
  84.          mx_internal::form.systemManager.stage.removeEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler);
  85.          mx_internal::form.systemManager.stage.removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  86.          mx_internal::form.removeEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  87.          mx_internal::form.removeEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  88.          mx_internal::form.systemManager.stage.removeEventListener(Event.ACTIVATE,activateHandler);
  89.          mx_internal::form.systemManager.stage.removeEventListener(Event.DEACTIVATE,deactivateHandler);
  90.          mx_internal::form.removeEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  91.          mx_internal::form.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  92.          activated = false;
  93.       }
  94.       
  95.       private function getIndexOfNextObject(param1:int, param2:Boolean, param3:Boolean, param4:String) : int
  96.       {
  97.          var _loc7_:DisplayObject = null;
  98.          var _loc8_:IFocusManagerGroup = null;
  99.          var _loc9_:int = 0;
  100.          var _loc10_:DisplayObject = null;
  101.          var _loc11_:IFocusManagerGroup = null;
  102.          var _loc5_:int = int(focusableCandidates.length);
  103.          var _loc6_:int = param1;
  104.          while(true)
  105.          {
  106.             if(param2)
  107.             {
  108.                param1--;
  109.             }
  110.             else
  111.             {
  112.                param1++;
  113.             }
  114.             if(param3)
  115.             {
  116.                if(param2 && param1 < 0)
  117.                {
  118.                   break;
  119.                }
  120.                if(!param2 && param1 == _loc5_)
  121.                {
  122.                   break;
  123.                }
  124.             }
  125.             else
  126.             {
  127.                param1 = (param1 + _loc5_) % _loc5_;
  128.                if(_loc6_ == param1)
  129.                {
  130.                   break;
  131.                }
  132.             }
  133.             if(isValidFocusCandidate(focusableCandidates[param1],param4))
  134.             {
  135.                _loc7_ = DisplayObject(findFocusManagerComponent(focusableCandidates[param1]));
  136.                if(_loc7_ is IFocusManagerGroup)
  137.                {
  138.                   _loc8_ = IFocusManagerGroup(_loc7_);
  139.                   _loc9_ = 0;
  140.                   while(_loc9_ < focusableCandidates.length)
  141.                   {
  142.                      _loc10_ = focusableCandidates[_loc9_];
  143.                      if(_loc10_ is IFocusManagerGroup)
  144.                      {
  145.                         _loc11_ = IFocusManagerGroup(_loc10_);
  146.                         if(_loc11_.groupName == _loc8_.groupName && _loc11_.selected)
  147.                         {
  148.                            if(InteractiveObject(_loc10_).tabIndex != InteractiveObject(_loc7_).tabIndex && !_loc8_.selected)
  149.                            {
  150.                               return getIndexOfNextObject(param1,param2,param3,param4);
  151.                            }
  152.                            param1 = _loc9_;
  153.                            break;
  154.                         }
  155.                      }
  156.                      _loc9_++;
  157.                   }
  158.                }
  159.                return param1;
  160.             }
  161.          }
  162.          return param1;
  163.       }
  164.       
  165.       private function mouseFocusChangeHandler(param1:FocusEvent) : void
  166.       {
  167.          var _loc2_:TextField = null;
  168.          if(param1.relatedObject is TextField)
  169.          {
  170.             _loc2_ = param1.relatedObject as TextField;
  171.             if(_loc2_.type == "input" || _loc2_.selectable)
  172.             {
  173.                return;
  174.             }
  175.          }
  176.          param1.preventDefault();
  177.       }
  178.       
  179.       mx_internal function set form(param1:IFocusManagerContainer) : void
  180.       {
  181.          _form = param1;
  182.       }
  183.       
  184.       private function addFocusables(param1:DisplayObject, param2:Boolean = false) : void
  185.       {
  186.          var focusable:IFocusManagerComponent = null;
  187.          var doc:DisplayObjectContainer = null;
  188.          var i:int = 0;
  189.          var rawChildren:IChildList = null;
  190.          var o:DisplayObject = param1;
  191.          var skipTopLevel:Boolean = param2;
  192.          if(o is IFocusManagerComponent && !skipTopLevel)
  193.          {
  194.             focusable = IFocusManagerComponent(o);
  195.             if(focusable.focusEnabled)
  196.             {
  197.                if(Boolean(focusable.tabEnabled) && isTabVisible(o))
  198.                {
  199.                   focusableObjects.push(o);
  200.                   calculateCandidates = true;
  201.                }
  202.                o.addEventListener("tabEnabledChange",tabEnabledChangeHandler);
  203.                o.addEventListener("tabIndexChange",tabIndexChangeHandler);
  204.             }
  205.          }
  206.          if(o is DisplayObjectContainer)
  207.          {
  208.             doc = DisplayObjectContainer(o);
  209.             o.addEventListener("tabChildrenChange",tabChildrenChangeHandler);
  210.             if(doc.tabChildren)
  211.             {
  212.                if(o is IRawChildrenContainer)
  213.                {
  214.                   rawChildren = IRawChildrenContainer(o).rawChildren;
  215.                   i = 0;
  216.                   while(i < rawChildren.numChildren)
  217.                   {
  218.                      try
  219.                      {
  220.                         addFocusables(rawChildren.getChildAt(i));
  221.                      }
  222.                      catch(error:SecurityError)
  223.                      {
  224.                      }
  225.                      i++;
  226.                   }
  227.                }
  228.                else
  229.                {
  230.                   i = 0;
  231.                   while(i < doc.numChildren)
  232.                   {
  233.                      try
  234.                      {
  235.                         addFocusables(doc.getChildAt(i));
  236.                      }
  237.                      catch(error:SecurityError)
  238.                      {
  239.                      }
  240.                      i++;
  241.                   }
  242.                }
  243.             }
  244.          }
  245.       }
  246.       
  247.       private function getMaxTabIndex() : int
  248.       {
  249.          var _loc4_:Number = NaN;
  250.          var _loc1_:Number = 0;
  251.          var _loc2_:int = int(focusableObjects.length);
  252.          var _loc3_:int = 0;
  253.          while(_loc3_ < _loc2_)
  254.          {
  255.             _loc4_ = Number(focusableObjects[_loc3_].tabIndex);
  256.             if(!isNaN(_loc4_))
  257.             {
  258.                _loc1_ = Math.max(_loc1_,_loc4_);
  259.             }
  260.             _loc3_++;
  261.          }
  262.          return _loc1_;
  263.       }
  264.       
  265.       private function showHandler(param1:Event) : void
  266.       {
  267.          mx_internal::form.systemManager.activate(mx_internal::form);
  268.       }
  269.       
  270.       public function toString() : String
  271.       {
  272.          return Object(mx_internal::form).toString() + ".focusManager";
  273.       }
  274.       
  275.       private function mouseDownHandler(param1:MouseEvent) : void
  276.       {
  277.          if(param1.isDefaultPrevented())
  278.          {
  279.             return;
  280.          }
  281.          var _loc2_:DisplayObject = getTopLevelFocusTarget(InteractiveObject(param1.target));
  282.          if(!_loc2_)
  283.          {
  284.             return;
  285.          }
  286.          showFocusIndicator = false;
  287.          if((_loc2_ != lastFocus || lastAction == "ACTIVATE") && !(_loc2_ is TextField))
  288.          {
  289.             setFocus(IFocusManagerComponent(_loc2_));
  290.          }
  291.          lastAction = "MOUSEDOWN";
  292.       }
  293.       
  294.       private function sortByDepth(param1:IFocusManagerComponent, param2:IFocusManagerComponent) : Number
  295.       {
  296.          var _loc5_:int = 0;
  297.          var _loc6_:String = null;
  298.          var _loc7_:String = null;
  299.          var _loc3_:String = "";
  300.          var _loc4_:String = "";
  301.          var _loc8_:String = "0000";
  302.          var _loc9_:DisplayObject = DisplayObject(param1);
  303.          var _loc10_:DisplayObject = DisplayObject(param2);
  304.          while(_loc9_ != DisplayObject(mx_internal::form) && Boolean(_loc9_.parent))
  305.          {
  306.             _loc5_ = getChildIndex(_loc9_.parent,_loc9_);
  307.             _loc6_ = _loc5_.toString(16);
  308.             if(_loc6_.length < 4)
  309.             {
  310.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  311.             }
  312.             _loc3_ = _loc7_ + _loc3_;
  313.             _loc9_ = _loc9_.parent;
  314.          }
  315.          while(_loc10_ != DisplayObject(mx_internal::form) && Boolean(_loc10_.parent))
  316.          {
  317.             _loc5_ = getChildIndex(_loc10_.parent,_loc10_);
  318.             _loc6_ = _loc5_.toString(16);
  319.             if(_loc6_.length < 4)
  320.             {
  321.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  322.             }
  323.             _loc4_ = _loc7_ + _loc4_;
  324.             _loc10_ = _loc10_.parent;
  325.          }
  326.          return _loc3_ > _loc4_ ? 1 : (_loc3_ < _loc4_ ? -1 : 0);
  327.       }
  328.       
  329.       private function focusOutHandler(param1:FocusEvent) : void
  330.       {
  331.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  332.       }
  333.       
  334.       public function setFocus(param1:IFocusManagerComponent) : void
  335.       {
  336.          param1.setFocus();
  337.       }
  338.       
  339.       private function getChildIndex(param1:DisplayObjectContainer, param2:DisplayObject) : int
  340.       {
  341.          var parent:DisplayObjectContainer = param1;
  342.          var child:DisplayObject = param2;
  343.          try
  344.          {
  345.             return parent.getChildIndex(child);
  346.          }
  347.          catch(e:Error)
  348.          {
  349.             if(parent is IRawChildrenContainer)
  350.             {
  351.                return IRawChildrenContainer(parent).rawChildren.getChildIndex(child);
  352.             }
  353.             throw e;
  354.          }
  355.       }
  356.       
  357.       public function findFocusManagerComponent(param1:InteractiveObject) : IFocusManagerComponent
  358.       {
  359.          while(param1)
  360.          {
  361.             if(param1 is IFocusManagerComponent && Boolean(IFocusManagerComponent(param1).focusEnabled))
  362.             {
  363.                return IFocusManagerComponent(param1);
  364.             }
  365.             param1 = param1.parent;
  366.          }
  367.          return null;
  368.       }
  369.       
  370.       private function sortFocusableObjectsTabIndex() : void
  371.       {
  372.          var _loc3_:IFocusManagerComponent = null;
  373.          focusableCandidates = [];
  374.          var _loc1_:int = int(focusableObjects.length);
  375.          var _loc2_:int = 0;
  376.          while(_loc2_ < _loc1_)
  377.          {
  378.             _loc3_ = focusableObjects[_loc2_];
  379.             if(Boolean(_loc3_.tabIndex) && !isNaN(Number(_loc3_.tabIndex)))
  380.             {
  381.                focusableCandidates.push(_loc3_);
  382.             }
  383.             _loc2_++;
  384.          }
  385.          focusableCandidates.sort(sortByTabIndex);
  386.       }
  387.       
  388.       private function removeFocusables(param1:DisplayObject, param2:Boolean) : void
  389.       {
  390.          var _loc3_:int = 0;
  391.          if(param1 is DisplayObjectContainer)
  392.          {
  393.             if(!param2)
  394.             {
  395.                param1.removeEventListener("tabChildrenChange",tabChildrenChangeHandler);
  396.             }
  397.             _loc3_ = 0;
  398.             while(_loc3_ < focusableObjects.length)
  399.             {
  400.                if(isParent(DisplayObjectContainer(param1),focusableObjects[_loc3_]))
  401.                {
  402.                   if(focusableObjects[_loc3_] == lastFocus)
  403.                   {
  404.                      lastFocus.drawFocus(false);
  405.                      lastFocus = null;
  406.                   }
  407.                   focusableObjects[_loc3_].removeEventListener("tabEnabledChange",tabEnabledChangeHandler);
  408.                   focusableObjects[_loc3_].removeEventListener("tabIndexChange",tabIndexChangeHandler);
  409.                   focusableObjects.splice(_loc3_,1);
  410.                   _loc3_--;
  411.                   calculateCandidates = true;
  412.                }
  413.                _loc3_++;
  414.             }
  415.          }
  416.       }
  417.       
  418.       private function setFocusToNextObject(param1:FocusEvent) : void
  419.       {
  420.          if(focusableObjects.length == 0)
  421.          {
  422.             return;
  423.          }
  424.          var _loc2_:IFocusManagerComponent = getNextFocusManagerComponent(param1.shiftKey);
  425.          if(_loc2_)
  426.          {
  427.             if(_loc2_ is IFocusManagerComplexComponent)
  428.             {
  429.                IFocusManagerComplexComponent(_loc2_).assignFocus(param1.shiftKey ? "bottom" : "top");
  430.             }
  431.             else
  432.             {
  433.                setFocus(_loc2_);
  434.             }
  435.          }
  436.       }
  437.       
  438.       private function getTopLevelFocusTarget(param1:InteractiveObject) : InteractiveObject
  439.       {
  440.          while(param1 != InteractiveObject(mx_internal::form))
  441.          {
  442.             if(param1 is IFocusManagerComponent && Boolean(IFocusManagerComponent(param1).focusEnabled) && Boolean(IFocusManagerComponent(param1).mouseFocusEnabled) && (param1 is IUIComponent ? IUIComponent(param1).enabled : true))
  443.             {
  444.                return param1;
  445.             }
  446.             param1 = param1.parent;
  447.             if(param1 == null)
  448.             {
  449.                break;
  450.             }
  451.          }
  452.          return null;
  453.       }
  454.       
  455.       public function set defaultButton(param1:IButton) : void
  456.       {
  457.          var _loc2_:IButton = !!param1 ? IButton(param1) : null;
  458.          if(_loc2_ != _defaultButton)
  459.          {
  460.             if(_defaultButton)
  461.             {
  462.                _defaultButton.emphasized = false;
  463.             }
  464.             if(defButton)
  465.             {
  466.                defButton.emphasized = false;
  467.             }
  468.             _defaultButton = _loc2_;
  469.             defButton = _loc2_;
  470.             if(_loc2_)
  471.             {
  472.                _loc2_.emphasized = true;
  473.             }
  474.          }
  475.       }
  476.       
  477.       mx_internal function sendDefaultButtonEvent() : void
  478.       {
  479.          defButton.dispatchEvent(new MouseEvent("click"));
  480.       }
  481.       
  482.       public function getFocus() : IFocusManagerComponent
  483.       {
  484.          var _loc1_:InteractiveObject = mx_internal::form.systemManager.stage.focus;
  485.          return findFocusManagerComponent(_loc1_);
  486.       }
  487.       
  488.       private function isEnabledAndVisible(param1:DisplayObject) : Boolean
  489.       {
  490.          var _loc2_:DisplayObjectContainer = DisplayObject(mx_internal::form).parent;
  491.          while(param1 != _loc2_)
  492.          {
  493.             if(param1 is IUIComponent)
  494.             {
  495.                if(!IUIComponent(param1).enabled)
  496.                {
  497.                   return false;
  498.                }
  499.             }
  500.             if(!param1.visible)
  501.             {
  502.                return false;
  503.             }
  504.             param1 = param1.parent;
  505.          }
  506.          return true;
  507.       }
  508.       
  509.       private function deactivateHandler(param1:Event) : void
  510.       {
  511.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  512.       }
  513.       
  514.       private function hideHandler(param1:Event) : void
  515.       {
  516.          mx_internal::form.systemManager.deactivate(mx_internal::form);
  517.       }
  518.       
  519.       private function addedHandler(param1:Event) : void
  520.       {
  521.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  522.          if(_loc2_.stage)
  523.          {
  524.             addFocusables(DisplayObject(param1.target));
  525.          }
  526.       }
  527.       
  528.       public function hideFocus() : void
  529.       {
  530.          if(showFocusIndicator)
  531.          {
  532.             showFocusIndicator = false;
  533.             if(lastFocus)
  534.             {
  535.                lastFocus.drawFocus(false);
  536.             }
  537.          }
  538.       }
  539.       
  540.       private function tabChildrenChangeHandler(param1:Event) : void
  541.       {
  542.          if(param1.target != param1.currentTarget)
  543.          {
  544.             return;
  545.          }
  546.          calculateCandidates = true;
  547.          var _loc2_:DisplayObjectContainer = DisplayObjectContainer(param1.target);
  548.          if(_loc2_.tabChildren)
  549.          {
  550.             addFocusables(_loc2_,true);
  551.          }
  552.          else
  553.          {
  554.             removeFocusables(_loc2_,true);
  555.          }
  556.       }
  557.       
  558.       private function isValidFocusCandidate(param1:DisplayObject, param2:String) : Boolean
  559.       {
  560.          var _loc3_:IFocusManagerGroup = null;
  561.          if(!isEnabledAndVisible(param1))
  562.          {
  563.             return false;
  564.          }
  565.          if(param1 is IFocusManagerGroup)
  566.          {
  567.             _loc3_ = IFocusManagerGroup(param1);
  568.             if(param2 == _loc3_.groupName)
  569.             {
  570.                return false;
  571.             }
  572.          }
  573.          return true;
  574.       }
  575.       
  576.       public function set focusPane(param1:Sprite) : void
  577.       {
  578.          _focusPane = param1;
  579.       }
  580.       
  581.       private function keyFocusChangeHandler(param1:FocusEvent) : void
  582.       {
  583.          showFocusIndicator = true;
  584.          if(param1.keyCode == Keyboard.TAB && !param1.isDefaultPrevented())
  585.          {
  586.             if(browserFocusComponent)
  587.             {
  588.                if(browserFocusComponent.tabIndex == LARGE_TAB_INDEX)
  589.                {
  590.                   browserFocusComponent.tabIndex = -1;
  591.                }
  592.                browserFocusComponent = null;
  593.                return;
  594.             }
  595.             setFocusToNextObject(param1);
  596.             param1.preventDefault();
  597.          }
  598.       }
  599.       
  600.       private function getIndexOfFocusedObject(param1:DisplayObject) : int
  601.       {
  602.          var _loc4_:IUIComponent = null;
  603.          if(!param1)
  604.          {
  605.             return -1;
  606.          }
  607.          var _loc2_:int = int(focusableCandidates.length);
  608.          var _loc3_:int = 0;
  609.          _loc3_ = 0;
  610.          while(_loc3_ < _loc2_)
  611.          {
  612.             if(focusableCandidates[_loc3_] == param1)
  613.             {
  614.                return _loc3_;
  615.             }
  616.             _loc3_++;
  617.          }
  618.          _loc3_ = 0;
  619.          while(_loc3_ < _loc2_)
  620.          {
  621.             _loc4_ = focusableCandidates[_loc3_] as IUIComponent;
  622.             if((Boolean(_loc4_)) && Boolean(_loc4_.owns(param1)))
  623.             {
  624.                return _loc3_;
  625.             }
  626.             _loc3_++;
  627.          }
  628.          return -1;
  629.       }
  630.       
  631.       private function isParent(param1:DisplayObjectContainer, param2:DisplayObject) : Boolean
  632.       {
  633.          if(param1 is IRawChildrenContainer)
  634.          {
  635.             return IRawChildrenContainer(param1).rawChildren.contains(param2);
  636.          }
  637.          return param1.contains(param2);
  638.       }
  639.       
  640.       private function removedHandler(param1:Event) : void
  641.       {
  642.          var _loc2_:int = 0;
  643.          var _loc3_:DisplayObject = DisplayObject(param1.target);
  644.          if(_loc3_ is IFocusManagerComponent)
  645.          {
  646.             _loc2_ = 0;
  647.             while(_loc2_ < focusableObjects.length)
  648.             {
  649.                if(_loc3_ == focusableObjects[_loc2_])
  650.                {
  651.                   if(_loc3_ == lastFocus)
  652.                   {
  653.                      lastFocus.drawFocus(false);
  654.                      lastFocus = null;
  655.                   }
  656.                   _loc3_.removeEventListener("tabEnabledChange",tabEnabledChangeHandler);
  657.                   _loc3_.removeEventListener("tabIndexChange",tabIndexChangeHandler);
  658.                   focusableObjects.splice(_loc2_,1);
  659.                   calculateCandidates = true;
  660.                   break;
  661.                }
  662.                _loc2_++;
  663.             }
  664.          }
  665.          removeFocusables(_loc3_,false);
  666.       }
  667.       
  668.       mx_internal function get form() : IFocusManagerContainer
  669.       {
  670.          return _form;
  671.       }
  672.       
  673.       private function tabIndexChangeHandler(param1:Event) : void
  674.       {
  675.          calculateCandidates = true;
  676.       }
  677.       
  678.       private function sortFocusableObjects() : void
  679.       {
  680.          var _loc3_:InteractiveObject = null;
  681.          focusableCandidates = [];
  682.          var _loc1_:int = int(focusableObjects.length);
  683.          var _loc2_:int = 0;
  684.          while(_loc2_ < _loc1_)
  685.          {
  686.             _loc3_ = focusableObjects[_loc2_];
  687.             if(_loc3_.tabIndex && !isNaN(Number(_loc3_.tabIndex)) && _loc3_.tabIndex > 0)
  688.             {
  689.                sortFocusableObjectsTabIndex();
  690.                return;
  691.             }
  692.             focusableCandidates.push(_loc3_);
  693.             _loc2_++;
  694.          }
  695.          focusableCandidates.sort(sortByDepth);
  696.       }
  697.       
  698.       public function get nextTabIndex() : int
  699.       {
  700.          return getMaxTabIndex() + 1;
  701.       }
  702.       
  703.       public function get defaultButton() : IButton
  704.       {
  705.          return _defaultButton;
  706.       }
  707.       
  708.       public function showFocus() : void
  709.       {
  710.          if(!showFocusIndicator)
  711.          {
  712.             showFocusIndicator = true;
  713.             if(lastFocus)
  714.             {
  715.                lastFocus.drawFocus(true);
  716.             }
  717.          }
  718.       }
  719.       
  720.       private function activateHandler(param1:Event) : void
  721.       {
  722.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  723.          if(Boolean(lastFocus) && !browserMode)
  724.          {
  725.             lastFocus.setFocus();
  726.          }
  727.          lastAction = "ACTIVATE";
  728.       }
  729.       
  730.       public function getNextFocusManagerComponent(param1:Boolean = false) : IFocusManagerComponent
  731.       {
  732.          var _loc8_:IFocusManagerGroup = null;
  733.          if(focusableObjects.length == 0)
  734.          {
  735.             return null;
  736.          }
  737.          if(calculateCandidates)
  738.          {
  739.             sortFocusableObjects();
  740.             calculateCandidates = false;
  741.          }
  742.          var _loc2_:DisplayObject = mx_internal::form.systemManager.stage.focus;
  743.          _loc2_ = DisplayObject(findFocusManagerComponent(InteractiveObject(_loc2_)));
  744.          var _loc3_:String = "";
  745.          if(_loc2_ is IFocusManagerGroup)
  746.          {
  747.             _loc8_ = IFocusManagerGroup(_loc2_);
  748.             _loc3_ = _loc8_.groupName;
  749.          }
  750.          var _loc4_:int = getIndexOfFocusedObject(_loc2_);
  751.          var _loc5_:Boolean = false;
  752.          var _loc6_:int = _loc4_;
  753.          if(_loc4_ == -1)
  754.          {
  755.             if(param1)
  756.             {
  757.                _loc4_ = int(focusableCandidates.length);
  758.             }
  759.             _loc5_ = true;
  760.          }
  761.          var _loc7_:int = getIndexOfNextObject(_loc4_,param1,_loc5_,_loc3_);
  762.          return findFocusManagerComponent(focusableCandidates[_loc7_]);
  763.       }
  764.       
  765.       public function get focusPane() : Sprite
  766.       {
  767.          return _focusPane;
  768.       }
  769.       
  770.       public function set defaultButtonEnabled(param1:Boolean) : void
  771.       {
  772.          _defaultButtonEnabled = param1;
  773.       }
  774.       
  775.       private function keyDownHandler(param1:KeyboardEvent) : void
  776.       {
  777.          var _loc3_:DisplayObject = null;
  778.          var _loc4_:String = null;
  779.          var _loc5_:int = 0;
  780.          var _loc6_:int = 0;
  781.          var _loc7_:IFocusManagerGroup = null;
  782.          var _loc2_:SystemManager = mx_internal::form.systemManager as SystemManager;
  783.          if(_loc2_)
  784.          {
  785.             _loc2_.mx_internal::idleCounter = 0;
  786.          }
  787.          if(param1.keyCode == Keyboard.TAB)
  788.          {
  789.             lastAction = "KEY";
  790.             if(calculateCandidates)
  791.             {
  792.                sortFocusableObjects();
  793.                calculateCandidates = false;
  794.             }
  795.          }
  796.          if(browserMode)
  797.          {
  798.             if(param1.keyCode == Keyboard.TAB && focusableCandidates.length > 0)
  799.             {
  800.                _loc3_ = mx_internal::form.systemManager.stage.focus;
  801.                _loc3_ = DisplayObject(findFocusManagerComponent(InteractiveObject(_loc3_)));
  802.                _loc4_ = "";
  803.                if(_loc3_ is IFocusManagerGroup)
  804.                {
  805.                   _loc7_ = IFocusManagerGroup(_loc3_);
  806.                   _loc4_ = _loc7_.groupName;
  807.                }
  808.                _loc5_ = getIndexOfFocusedObject(_loc3_);
  809.                _loc6_ = getIndexOfNextObject(_loc5_,param1.shiftKey,false,_loc4_);
  810.                if(param1.shiftKey)
  811.                {
  812.                   if(_loc6_ >= _loc5_)
  813.                   {
  814.                      browserFocusComponent = mx_internal::form.systemManager.stage.focus;
  815.                      if(browserFocusComponent.tabIndex == -1)
  816.                      {
  817.                         browserFocusComponent.tabIndex = 0;
  818.                      }
  819.                   }
  820.                }
  821.                else if(_loc6_ <= _loc5_)
  822.                {
  823.                   browserFocusComponent = mx_internal::form.systemManager.stage.focus;
  824.                   if(browserFocusComponent.tabIndex == -1)
  825.                   {
  826.                      browserFocusComponent.tabIndex = LARGE_TAB_INDEX;
  827.                   }
  828.                }
  829.             }
  830.          }
  831.          if(defaultButtonEnabled && param1.keyCode == Keyboard.ENTER && defaultButton && Boolean(defButton.enabled))
  832.          {
  833.             defButton.callLater(mx_internal::sendDefaultButtonEvent);
  834.          }
  835.       }
  836.       
  837.       private function focusInHandler(param1:FocusEvent) : void
  838.       {
  839.          var _loc3_:IButton = null;
  840.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  841.          if(isParent(DisplayObjectContainer(mx_internal::form),_loc2_))
  842.          {
  843.             lastFocus = findFocusManagerComponent(InteractiveObject(_loc2_));
  844.             if(lastFocus is IButton)
  845.             {
  846.                _loc3_ = lastFocus as IButton;
  847.                if(defButton)
  848.                {
  849.                   defButton.emphasized = false;
  850.                   defButton = _loc3_;
  851.                   _loc3_.emphasized = true;
  852.                }
  853.             }
  854.             else if(Boolean(defButton) && defButton != _defaultButton)
  855.             {
  856.                defButton.emphasized = false;
  857.                defButton = _defaultButton;
  858.                _defaultButton.emphasized = true;
  859.             }
  860.          }
  861.       }
  862.       
  863.       public function set showFocusIndicator(param1:Boolean) : void
  864.       {
  865.          _showFocusIndicator = param1;
  866.       }
  867.       
  868.       private function sortByTabIndex(param1:IFocusManagerComponent, param2:IFocusManagerComponent) : int
  869.       {
  870.          var _loc3_:int = int(param1.tabIndex);
  871.          var _loc4_:int = int(param2.tabIndex);
  872.          if(_loc3_ == -1)
  873.          {
  874.             _loc3_ = int.MAX_VALUE;
  875.          }
  876.          if(_loc4_ == -1)
  877.          {
  878.             _loc4_ = int.MAX_VALUE;
  879.          }
  880.          return _loc3_ > _loc4_ ? 1 : (_loc3_ < _loc4_ ? -1 : int(sortByDepth(param1,param2)));
  881.       }
  882.       
  883.       public function activate() : void
  884.       {
  885.          if(activated)
  886.          {
  887.             return;
  888.          }
  889.          mx_internal::form.systemManager.stage.addEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler,false,0,true);
  890.          mx_internal::form.systemManager.stage.addEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler,false,0,true);
  891.          mx_internal::form.addEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  892.          mx_internal::form.addEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  893.          mx_internal::form.systemManager.stage.addEventListener(Event.ACTIVATE,activateHandler,false,0,true);
  894.          mx_internal::form.systemManager.stage.addEventListener(Event.DEACTIVATE,deactivateHandler,false,0,true);
  895.          mx_internal::form.addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  896.          mx_internal::form.addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  897.          activated = true;
  898.          if(lastFocus)
  899.          {
  900.             setFocus(lastFocus);
  901.          }
  902.       }
  903.       
  904.       public function get defaultButtonEnabled() : Boolean
  905.       {
  906.          return _defaultButtonEnabled;
  907.       }
  908.       
  909.       private function isTabVisible(param1:DisplayObject) : Boolean
  910.       {
  911.          var _loc2_:DisplayObject = DisplayObject(mx_internal::form.systemManager);
  912.          if(!_loc2_)
  913.          {
  914.             return false;
  915.          }
  916.          var _loc3_:DisplayObjectContainer = param1.parent;
  917.          while(Boolean(_loc3_) && _loc3_ != _loc2_)
  918.          {
  919.             if(!_loc3_.tabChildren)
  920.             {
  921.                return false;
  922.             }
  923.             _loc3_ = _loc3_.parent;
  924.          }
  925.          return true;
  926.       }
  927.       
  928.       private function creationCompleteHandler(param1:FlexEvent) : void
  929.       {
  930.          if(DisplayObject(mx_internal::form).visible && !activated)
  931.          {
  932.             mx_internal::form.systemManager.activate(mx_internal::form);
  933.          }
  934.       }
  935.       
  936.       public function get showFocusIndicator() : Boolean
  937.       {
  938.          return _showFocusIndicator;
  939.       }
  940.       
  941.       private function tabEnabledChangeHandler(param1:Event) : void
  942.       {
  943.          calculateCandidates = true;
  944.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  945.          var _loc3_:int = int(focusableObjects.length);
  946.          var _loc4_:int = 0;
  947.          while(_loc4_ < _loc3_)
  948.          {
  949.             if(focusableObjects[_loc4_] == _loc2_)
  950.             {
  951.                break;
  952.             }
  953.             _loc4_++;
  954.          }
  955.          if(_loc2_.tabEnabled)
  956.          {
  957.             if(_loc4_ == _loc3_ && isTabVisible(_loc2_))
  958.             {
  959.                focusableObjects.push(_loc2_);
  960.             }
  961.          }
  962.          else if(_loc4_ < _loc3_)
  963.          {
  964.             focusableObjects.splice(_loc4_,1);
  965.          }
  966.       }
  967.    }
  968. }
  969.  
  970.